1512D - Corrupted Array - CodeForces Solution

from math import log
from math import ceil
import os
import sys
from collections import Counter as ctr, deque as dq,defaultdict as dd
from io import BytesIO, IOBase
from types import GeneratorType

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0
 
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = 'x' in file.mode or 'r' not in file.mode
        self.write = self.buffer.write if self.writable else None
 
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
 
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b'\n') + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
 
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
 
 
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode('ascii'))
        self.read = lambda: self.buffer.read().decode('ascii')
        self.readline = lambda: self.buffer.readline().decode('ascii')
 
 
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')
 
from bisect import bisect_left as bl
from bisect import bisect_right as br

inp = lambda: int(input())
li = lambda: list(map(int, input().split()))
lb = lambda: list(map(int, input()))
ls = lambda: list(input())
bi = lambda n: bin(n).replace("0b", "")

def yn(f):
    if f:
        print("YES")
    else:
        print("NO")

def bootstrap(f, stack=[]):
    def wrappedfunc(*args, **kwargs):
        if stack:
            return f(*args, **kwargs)
        else:
            to = f(*args, **kwargs)
            while True:
                if type(to) is GeneratorType:
                    stack.append(to)
                    to = next(to)
                else:
                    stack.pop()
                    if not stack:
                        break
                    to = stack[-1].send(to)
            return to
 
    return wrappedfunc

def isPrime(n):
    if n <= 1:
        return True
    if n <= 3:
        return True
    if n % 2 == 0 or n % 3 == 0:
        return False
    i = 5
    while i * i <= n:
        if n % i == 0 or n % (i + 2) == 0:
            return False
        i = i + 6
    return True

def nf(n,a):
    b=a*a
    c=b*a
    d=c*a
    e=n
    ct=0
    while e%a==0:
        if e%d==0:
            ct+=4
            e=e//d
        if e%c==0:
            ct+=3
            e=e//c
        if e%b==0:
            ct+=2
            e=e//b
        if e%a==0:
            ct+=1
            e=e//a
    return ct

def main(__=1):
    for _ in range(__):
        n=inp()
        a=sorted(li())
        s=sum(a[:n+1])
        if s>a[-1] and (s-a[-1]) in a[:n+1]:
            f=False
            for i in range(n+1):
                if a[i]!=(s-a[-1]) or f:
                    print(a[i],end=" ")
                else:
                    f=True
            print()
        elif s-a[-2] == a[-2]:
            print(*a[:n])
        else:
            print(-1)

        

if __name__ == "__main__":
        main(inp())